package _case

import "fmt"

// 使用泛型处理 map 数据并通过通道（channel）进行数据处理
func TypeToCase() {
	m := make(map[int64]User)
	m[0] = User{1, "Jc", 18}
	listData1 := mapToList(m)
	ch1 := make(chan User)
	//printCh(ch) // 阻塞主线程，无法执行下面代码，导致死锁
	go printCh(ch1) // 避免阻塞主线程 使主线程能继续向通道发送数据，避免死锁
	for _, v := range listData1 {
		ch1 <- v
	}
	//关闭通道
	close(ch1)

	addr := make(map[int32]Address)
	addr[0] = Address{1, "广东", "深圳"}
	addr[1] = Address{2, "广西", "南宁"}
	listData2 := mapToList(addr)
	ch2 := make(chan Address)
	go printCh(ch2)
	for _, v := range listData2 {
		ch2 <- v
	}
	close(ch2)
}

func TypeToCaseT() {
	m := make(MapT[int64, User])
	m[0] = User{1, "Jc", 18}
	listData1 := mapToList(m)
	ch1 := make(ChanT[User])
	//printCh(ch) // 阻塞主线程，无法执行下面代码，导致死锁
	go printCh(ch1) // 避免阻塞主线程 使主线程能继续向通道发送数据，避免死锁
	for _, v := range listData1 {
		ch1 <- v
	}
	//关闭通道
	close(ch1)

	addr := make(MapT[int32, Address])
	addr[0] = Address{1, "广东", "深圳"}
	addr[1] = Address{2, "广西", "南宁"}
	listData2 := mapToList(addr)
	ch2 := make(ChanT[Address])
	go printCh(ch2)
	for _, v := range listData2 {
		ch2 <- v
	}
	close(ch2)

	nums := make(MapT[int32, int])
	nums[0] = 1
	nums[1] = 2
	numData := mapToList(nums)
	ch3 := make(ChanT[int])
	go printCh(ch3)
	for _, v := range numData {
		ch3 <- v
	}
}

type User struct {
	ID   int
	Name string
	Age  int
}

type Address struct {
	ID       int64
	Province string
	City     string
}

func mapToList[k comparable, T any](m map[k]T) []T {
	list := make([]T, len(m))
	var i = 0
	for _, v := range m {
		list[i] = v
		i++
	}
	return list
}

func printCh[T any](ch chan T) {
	for data := range ch {
		fmt.Printf("%+v\n", data)
	}
}

// 泛型切片的定义
type ListT[T any] []T

// 泛型集合的定义
type MapT[K comparable, V any] map[K]V

// 泛型通道
type ChanT[T any] chan T
